home *** CD-ROM | disk | FTP | other *** search
/ Aminet 35 / Aminet 35 (2000)(Schatztruhe)[!][Feb 2000].iso / Aminet / dev / src / stefanb_src.lha / Old_Projects / ToolManager / Source / library / LibInit.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-25  |  9.2 KB  |  317 lines
  1. /*
  2.  * LibInit.c  V2.1.02
  3.  *
  4.  * shared library C stub
  5.  *
  6.  * (c) 1990-1995 Stefan Becker
  7.  */
  8.  
  9. #include "ToolManagerLib.h"
  10.  
  11. /*
  12.  * Object file dummy entry point
  13.  */
  14. static ULONG Dummy(void)
  15. {
  16.  return(0);
  17. }
  18.  
  19. /* library name & id string */
  20. #define INTTOSTR(a) #a
  21. const char LibName[]=TMLIBNAME;
  22. const char LibId[]="$VER: " TMLIBNAME " " INTTOSTR(TMLIBVERSION) "."
  23.                    INTTOSTR(TMLIBREVISION) " (" __COMMODORE_DATE__ ")\r\n";
  24.  
  25. /* prototypes for library management functions */
  26. __geta4 static struct Library *LibInit(__A0 BPTR, __A6 struct Library *);
  27. __geta4 static struct Library *LibOpen(__A6 struct Library *);
  28. __geta4 static BPTR            LibClose(__A6 struct Library *);
  29. __geta4 static BPTR            LibExpunge(__A6 struct Library *);
  30.         static ULONG           LibReserved(void);
  31. __geta4 static void            QuitToolManager(void);
  32. __geta4 struct TMHandle       *AllocTMHandle(void);
  33. __geta4 static void            FreeTMHandle(__A0 struct TMHandle *);
  34. __geta4 static BOOL            CreateTMObjectTagList(__A0 struct TMHandle *,
  35.                                                      __A1 char *, __D0 ULONG,
  36.                                                      __A2 struct TagItem *);
  37. __geta4 static BOOL            DeleteTMObject(__A0 struct TMHandle *,
  38.                                               __A1 char *);
  39. __geta4 static BOOL            ChangeTMObjectTagList(__A0 struct TMHandle *,
  40.                                                      __A1 char *,
  41.                                                      __A2 struct TagItem *);
  42.  
  43. /* ROMTag structure */
  44. static const struct Resident ROMTag = {
  45.                                        RTC_MATCHWORD,
  46.                                        &ROMTag,
  47.                                        &ROMTag + 1,
  48.                                        0,             /* Flags */
  49.                                        TMLIBVERSION,
  50.                                        NT_LIBRARY,
  51.                                        0,             /* Priority */
  52.                                        LibName,
  53.                                        LibId,
  54.                                        LibInit
  55.                                       };
  56.  
  57. /* library functions table */
  58. static const APTR LibVectors[]={
  59.                                 /* Standard functions */
  60.                                 (APTR) LibOpen,
  61.                                 (APTR) LibClose,
  62.                                 (APTR) LibExpunge,
  63.                                 (APTR) NULL,
  64.  
  65.                                 /* Library specific functions */
  66.                                 (APTR) LibReserved, /* reserved for ARexx */
  67.                                 (APTR) QuitToolManager,
  68.                                 (APTR) AllocTMHandle,
  69.                                 (APTR) FreeTMHandle,
  70.                                 (APTR) CreateTMObjectTagList,
  71.                                 (APTR) DeleteTMObject,
  72.                                 (APTR) ChangeTMObjectTagList,
  73.  
  74.                                 /* Table end */
  75.                                 (APTR) -1
  76.                                 };
  77.  
  78. /* misc. data */
  79. static BPTR LibSegment=NULL;
  80. static struct Library *PrivateDOSBase=NULL;
  81. static struct Task *HandlerTask;
  82. struct Library *SysBase=NULL;
  83. struct Library *LibBase=NULL;
  84. BOOL Closing=FALSE;
  85. const char DosName[]="dos.library";
  86.  
  87. /* Prototype & pragma for local calls to CreateNewProc() */
  88. struct Task *MyCreateNewProc(struct TagItem *tags);
  89. #pragma libcall PrivateDOSBase MyCreateNewProc 1f2 101
  90.  
  91. /* library init routine */
  92. __geta4 static struct Library *LibInit(__A0 BPTR LibSegList,
  93.                                        __A6 struct Library *ExecBase)
  94. {
  95.  struct Library *MyLib;
  96.  
  97.  /* Initialize SysBase */
  98.  SysBase = ExecBase;
  99.  
  100.  /* Open dos.library */
  101.  if (!(PrivateDOSBase=OpenLibrary(DosName,37))) return(0);
  102.  
  103.  LibSegment=LibSegList;
  104.  
  105.  if (!(LibBase=MyLib=MakeLibrary(LibVectors, NULL, NULL,
  106.                                  sizeof(struct Library), NULL))) {
  107.   CloseLibrary(PrivateDOSBase);
  108.   return(0);
  109.  }
  110.  
  111.  MyLib->lib_Node.ln_Type=NT_LIBRARY;
  112.  MyLib->lib_Node.ln_Name=LibName;
  113.  MyLib->lib_Flags=LIBF_CHANGED|LIBF_SUMUSED;
  114.  MyLib->lib_Version=TMLIBVERSION;
  115.  MyLib->lib_Revision=TMLIBREVISION;
  116.  MyLib->lib_IdString=(APTR) LibId;
  117.  AddLibrary(MyLib);
  118.  
  119.  DEBUG_PRINTF("Init Lib: %08lx ",MyLib);
  120.  DEBUG_PRINTF("Seg: %08lx\n",LibSegment);
  121.  
  122.  return(MyLib);
  123. }
  124.  
  125. /* shared library open function */
  126. __geta4 static struct Library *LibOpen(__A6 struct Library *lib)
  127. {
  128.  /* Handle special case: OpenCnt=0 & Handler is just closing down */
  129.  if ((lib->lib_OpenCnt == 0) && Closing) return(NULL);
  130.  
  131.  /* Handler active? Try to start it... */
  132.  if (!LibraryPort && !(HandlerTask=MyCreateNewProc(HandlerProcessTags)))
  133.   return(NULL);
  134.  
  135.  /* Oh another user :-) */
  136.  lib->lib_OpenCnt++;
  137.  
  138.  /* Reset delayed expunge flag */
  139.  lib->lib_Flags&=~LIBF_DELEXP;
  140.  
  141.  /* Return library pointer */
  142.  DEBUG_PRINTF("Open Lib: %ld\n",lib->lib_OpenCnt);
  143.  return(lib);
  144. }
  145.  
  146. /* shared library close function */
  147. __geta4 static BPTR LibClose(__A6 struct Library *lib)
  148. {
  149.  /* Open count already zero or more than one user? */
  150.  if ((lib->lib_OpenCnt == 0) || (--lib->lib_OpenCnt > 0)) return(NULL);
  151.  
  152.  /* Is handler active? Yes, send him a signal if he should shut down */
  153.  if (LibraryPort && Closing) Signal(HandlerTask,SIGBREAKF_CTRL_F);
  154.  
  155.  /* Is the delayed expunge bit set?  Yes, try to remove the library */
  156.  if (lib->lib_Flags & LIBF_DELEXP) return(LibExpunge(lib));
  157.  
  158.  /* No. Don't remove library now */
  159.  return(NULL);
  160. }
  161.  
  162. /* shared library expunge function */
  163. __geta4 static BPTR LibExpunge(__A6 struct Library *lib)
  164. {
  165.  DEBUG_PRINTF("Expunge Lib: %08lx ",lib);
  166.  DEBUG_PRINTF("Seg: %08lx\n",LibSegment);
  167.  
  168.  /* Does no-one use library now or is handler active/closing down?? */
  169.  if ((lib->lib_OpenCnt > 0) || LibraryPort || Closing) {
  170.   /* No, library still in use -> set delayed expunge flag */
  171.   lib->lib_Flags|=LIBF_DELEXP;
  172.   return(NULL);
  173.  }
  174.  
  175.  /* Yes, remove library and free resources */
  176.  Remove(&lib->lib_Node);
  177.  FreeMem((void *) ((ULONG) lib-lib->lib_NegSize),
  178.          lib->lib_NegSize+lib->lib_PosSize);
  179.  if (PrivateDOSBase) {
  180.   CloseLibrary(PrivateDOSBase);
  181.   PrivateDOSBase=NULL;
  182.  }
  183.  
  184.  /* return BPTR to our seglist */
  185.  DEBUG_PUTSTR("Removing library...\n");
  186.  return(LibSegment);
  187. }
  188.  
  189. /* Reserved function, returns NULL */
  190. static ULONG LibReserved(void)
  191. {
  192.  return(NULL);
  193. }
  194.  
  195. /* Set quit flag for handler process */
  196. __geta4 static void QuitToolManager(void)
  197. {
  198.  /* Set flag */
  199.  if (LibraryPort && !Closing) Closing=TRUE;
  200. }
  201.  
  202. /* Send IPC message */
  203. static BOOL SendIPC(struct TMHandle *handle)
  204. {
  205.  /* Handler ready? */
  206.  if (LibraryPort) {
  207.   /* Yep, send message */
  208.   PutMsg(LibraryPort,(struct Message *) handle);
  209.  
  210.   /* Wait on reply */
  211.   WaitPort(handle->tmh_Msg.mn_ReplyPort);
  212.  
  213.   /* Get reply */
  214.   GetMsg(handle->tmh_Msg.mn_ReplyPort);
  215.  
  216.   /* get return code */
  217.   return(handle->tmh_Command);
  218.  }
  219.  
  220.  /* Oops nobody listening :-( */
  221.  return(FALSE);
  222. }
  223.  
  224. /* Allocate a TMHandle */
  225. __geta4 void *AllocTMHandle(void)
  226. {
  227.  struct TMHandle *handle;
  228.  
  229.  DEBUG_PRINTF("AllocTMHandle() called.\n");
  230.  
  231.  /* Allocate memory for handle structure */
  232.  if (handle=AllocMem(sizeof(struct TMHandle),MEMF_PUBLIC)) {
  233.   struct MsgPort *rp;
  234.  
  235.   /* Create IPC Port */
  236.   if (rp=CreateMsgPort()) {
  237.    /* Init message */
  238.    handle->tmh_Msg.mn_ReplyPort=rp;
  239.    handle->tmh_Msg.mn_Length=sizeof(struct TMHandle);
  240.  
  241.    /* Send command to handler */
  242.    handle->tmh_Command=TMIPC_AllocTMHandle;
  243.    if (SendIPC(handle)) return(handle); /* All OK. */
  244.  
  245.    /* Something went wrong */
  246.    DeleteMsgPort(handle->tmh_Msg.mn_ReplyPort);
  247.   }
  248.   FreeMem(handle,sizeof(struct TMHandle));
  249.  }
  250.  
  251.  /* call failed */
  252.  DEBUG_PRINTF("AllocTMHandle() failed.\n");
  253.  return(NULL);
  254. }
  255.  
  256. __geta4 static void FreeTMHandle(__A0 struct TMHandle *handle)
  257. {
  258.  /* Send command to handler */
  259.  handle->tmh_Command=TMIPC_FreeTMHandle;
  260.  SendIPC(handle);
  261.  
  262.  /* Free handle */
  263.  DeleteMsgPort(handle->tmh_Msg.mn_ReplyPort);
  264.  FreeMem(handle,sizeof(struct TMHandle));
  265. }
  266.  
  267. __geta4 BOOL CreateTMObjectTagList(__A0 struct TMHandle *handle,
  268.                                    __A1 char *object,
  269.                                    __D0 ULONG type,
  270.                                    __A2 struct TagItem *tags)
  271. {
  272.  /* Sanity checks */
  273.  if ((handle==NULL) || (object==NULL) || (type>=TMOBJTYPES))
  274.   return(FALSE); /* Bad arguments! */
  275.  
  276.  /* Build IPC command */
  277.  handle->tmh_Command=TMIPC_CreateTMObject;
  278.  handle->tmh_Type=type;
  279.  handle->tmh_Object=object;
  280.  handle->tmh_Tags=tags;
  281.  
  282.  /* Send command to handler */
  283.  return(SendIPC(handle));
  284. }
  285.  
  286. /* Delete a TMObject (shared library version) */
  287. __geta4 BOOL DeleteTMObject(__A0 struct TMHandle *handle, __A1 char *object)
  288. {
  289.  /* Sanity checks */
  290.  if ((handle==NULL) || (object==NULL)) return(FALSE); /* Bad arguments! */
  291.  
  292.  /* Build IPC command */
  293.  handle->tmh_Command=TMIPC_DeleteTMObject;
  294.  handle->tmh_Object=object;
  295.  
  296.  /* Send command to handler */
  297.  return(SendIPC(handle));
  298. }
  299.  
  300. /* Change a TMObject (shared library version) */
  301. __geta4 BOOL ChangeTMObjectTagList(__A0 struct TMHandle *handle,
  302.                                    __A1 char *object,
  303.                                    __A2 struct TagItem *tags)
  304. {
  305.  /* Sanity checks */
  306.  if ((handle==NULL) || (object==NULL)) return(FALSE); /* Bad arguments! */
  307.  
  308.  /* Build IPC command */
  309.  handle->tmh_Command=TMIPC_ChangeTMObject;
  310.  handle->tmh_Object=object;
  311.  handle->tmh_Tags=tags;
  312.  
  313.  /* Send command to handler */
  314.  return(SendIPC(handle));
  315. }
  316.  
  317.